#include <bits/stdc++.h>
using namespace std;

/*
2900. 最长相邻不相等子序列 I
已解答
简单
相关标签
相关企业
提示
给你一个下标从 0 开始的字符串数组 words ，和一个下标从 0 开始的 二进制 数组 groups ，两个数组长度都是 n 。

你需要从 words 中选出 最长子序列。如果对于序列中的任何两个连续串，二进制数组 groups 中它们的对应元素不同，则 words 的子序列是不同的。

正式来说，你需要从下标 [0, 1, ..., n - 1] 中选出一个 最长子序列 ，将这个子序列记作长度为 k 的 [i0, i1, ..., ik - 1] ，对于所有满足 0 <= j < k - 1 的 j 都有 groups[ij] != groups[ij + 1] 。

请你返回一个字符串数组，它是下标子序列 依次 对应 words 数组中的字符串连接形成的字符串数组。如果有多个答案，返回 任意 一个。

注意：words 中的元素是不同的 。

 

示例 1：

输入：words = ["e","a","b"], groups = [0,0,1]
输出：["e","b"]
解释：一个可行的子序列是 [0,2] ，因为 groups[0] != groups[2] 。
所以一个可行的答案是 [words[0],words[2]] = ["e","b"] 。
另一个可行的子序列是 [1,2] ，因为 groups[1] != groups[2] 。
得到答案为 [words[1],words[2]] = ["a","b"] 。
这也是一个可行的答案。
符合题意的最长子序列的长度为 2 。
示例 2：

输入：words = ["a","b","c","d"], groups = [1,0,1,1]
输出：["a","b","c"]
解释：一个可行的子序列为 [0,1,2] 因为 groups[0] != groups[1] 且 groups[1] != groups[2] 。
所以一个可行的答案是 [words[0],words[1],words[2]] = ["a","b","c"] 。
另一个可行的子序列为 [0,1,3] 因为 groups[0] != groups[1] 且 groups[1] != groups[3] 。
得到答案为 [words[0],words[1],words[3]] = ["a","b","d"] 。
这也是一个可行的答案。
符合题意的最长子序列的长度为 3 。
 

提示：

1 <= n == words.length == groups.length <= 100
1 <= words[i].length <= 10
groups[i] 是 0 或 1。
words 中的字符串 互不相同 。
words[i] 只包含小写英文字母。
*/

class Solution {
public:
    vector<string> getLongestSubsequence(vector<string>& words, vector<int>& groups) {
        int n = words.size();
        
        // 如果输入的 words 数组为空，直接返回空数组
        if (n == 0) return {};
        
        // dp[i] 表示以 i 结尾的最长子序列长度，初始化为 1（每个元素自己就是一个子序列）
        vector<int> dp(n, 1);
        
        // prev[i] 用于记录当前元素的前驱节点，用于重建最长子序列
        vector<int> prev(n, -1); 
        
        int max_len = 1;    // 记录最长子序列的长度
        int end_pos = 0;    // 记录最长子序列的最后一个元素的下标
        
        // 计算以每个元素为结尾的最长子序列
        for (int i = 1; i < n; ++i) {
            for (int j = 0; j < i; ++j) {
                // 确保前后元素属于不同的组
                if (groups[j] != groups[i]) {
                    // 如果以 j 为结尾的子序列长度加 1 大于以 i 为结尾的子序列长度
                    if (dp[j] + 1 > dp[i]) {
                        dp[i] = dp[j] + 1;  // 更新 dp[i]
                        prev[i] = j;         // 更新 prev[i] 为 j
                    }
                }
            }
            // 更新最长子序列长度及其结尾元素的位置
            if (dp[i] > max_len) {
                max_len = dp[i];
                end_pos = i;
            }
        }
        
        // 重建最长子序列
        vector<string> result;
        int current = end_pos;
        
        // 从最后一个元素开始，回溯直到到达第一个元素
        while (current != -1) {
            result.push_back(words[current]);
            current = prev[current];
        }
        
     // 由于回溯时的顺序是反的，所以需要反转结果
        reverse(result.begin(), result.end());
        
        return result;  // 返回最长子序列
    }
};
